home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 April: Mac OS SDK / Dev.CD Apr 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1998-02-12  |  67.0 KB  |  2,054 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Quickdraw.p
  3.  
  4.      Contains:    Interface to Quickdraw Graphics
  5.  
  6.      Version:    Technology:    Mac OS 8.1
  7.                  Release:    Universal Interfaces 3.1
  8.  
  9.      Copyright:    © 1985-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT Quickdraw;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __QUICKDRAW__}
  28. {$SETC __QUICKDRAW__ := 1}
  29.  
  30. {$I+}
  31. {$SETC QuickdrawIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __MACTYPES__}
  35. {$I MacTypes.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __MIXEDMODE__}
  38. {$I MixedMode.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __QUICKDRAWTEXT__}
  41. {$I QuickdrawText.p}
  42. {$ENDC}
  43.  
  44.  
  45. {$PUSH}
  46. {$ALIGN MAC68K}
  47. {$LibExport+}
  48.  
  49.  
  50. CONST
  51.     invalColReq                    = -1;                            { invalid color table request }
  52.  
  53.                                                                 {  transfer modes  }
  54.     srcCopy                        = 0;                            { the 16 transfer modes }
  55.     srcOr                        = 1;
  56.     srcXor                        = 2;
  57.     srcBic                        = 3;
  58.     notSrcCopy                    = 4;
  59.     notSrcOr                    = 5;
  60.     notSrcXor                    = 6;
  61.     notSrcBic                    = 7;
  62.     patCopy                        = 8;
  63.     patOr                        = 9;
  64.     patXor                        = 10;
  65.     patBic                        = 11;
  66.     notPatCopy                    = 12;
  67.     notPatOr                    = 13;
  68.     notPatXor                    = 14;
  69.     notPatBic                    = 15;                            {  Special Text Transfer Mode  }
  70.     grayishTextOr                = 49;
  71.     hilitetransfermode            = 50;
  72.     hilite                        = 50;                            {  Arithmetic transfer modes  }
  73.     blend                        = 32;
  74.     addPin                        = 33;
  75.     addOver                        = 34;
  76.     subPin                        = 35;
  77.     addMax                        = 37;
  78.     adMax                        = 37;
  79.     subOver                        = 38;
  80.     adMin                        = 39;
  81.     ditherCopy                    = 64;                            {  Transparent mode constant  }
  82.     transparent                    = 36;
  83.  
  84.     italicBit                    = 1;
  85.     ulineBit                    = 2;
  86.     outlineBit                    = 3;
  87.     shadowBit                    = 4;
  88.     condenseBit                    = 5;
  89.     extendBit                    = 6;
  90.  
  91.                                                                 {  QuickDraw color separation constants  }
  92.     normalBit                    = 0;                            { normal screen mapping }
  93.     inverseBit                    = 1;                            { inverse screen mapping }
  94.     redBit                        = 4;                            { RGB additive mapping }
  95.     greenBit                    = 3;
  96.     blueBit                        = 2;
  97.     cyanBit                        = 8;                            { CMYBk subtractive mapping }
  98.     magentaBit                    = 7;
  99.     yellowBit                    = 6;
  100.     blackBit                    = 5;
  101.  
  102.     blackColor                    = 33;                            { colors expressed in these mappings }
  103.     whiteColor                    = 30;
  104.     redColor                    = 205;
  105.     greenColor                    = 341;
  106.     blueColor                    = 409;
  107.     cyanColor                    = 273;
  108.     magentaColor                = 137;
  109.     yellowColor                    = 69;
  110.  
  111.     picLParen                    = 0;                            { standard picture comments }
  112.     picRParen                    = 1;
  113.     clutType                    = 0;                            { 0 if lookup table }
  114.     fixedType                    = 1;                            { 1 if fixed table }
  115.     directType                    = 2;                            { 2 if direct values }
  116.     gdDevType                    = 0;                            { 0 = monochrome 1 = color }
  117.  
  118.     interlacedDevice            = 2;                            {  1 if single pixel lines look bad  }
  119.     roundedDevice                = 5;                            {  1 if device has been “rounded” into the GrayRgn  }
  120.     hasAuxMenuBar                = 6;                            {  1 if device has an aux menu bar on it  }
  121.     burstDevice                    = 7;
  122.     ext32Device                    = 8;
  123.     ramInit                        = 10;                            { 1 if initialized from 'scrn' resource }
  124.     mainScreen                    = 11;                            {  1 if main screen  }
  125.     allInit                        = 12;                            {  1 if all devices initialized  }
  126.     screenDevice                = 13;                            { 1 if screen device [not used] }
  127.     noDriver                    = 14;                            {  1 if no driver for this GDevice  }
  128.     screenActive                = 15;                            { 1 if in use }
  129.     hiliteBit                    = 7;                            { flag bit in HiliteMode (lowMem flag) }
  130.     pHiliteBit                    = 0;                            { flag bit in HiliteMode used with BitClr procedure }
  131.     defQDColors                    = 127;                            { resource ID of clut for default QDColors }
  132.                                                                 {  pixel type  }
  133.     RGBDirect                    = 16;                            {  16 & 32 bits/pixel pixelType value  }
  134.                                                                 {  pmVersion values  }
  135.     baseAddr32                    = 4;                            { pixmap base address is 32-bit address }
  136.  
  137.  
  138.     sysPatListID                = 0;
  139.     iBeamCursor                    = 1;
  140.     crossCursor                    = 2;
  141.     plusCursor                    = 3;
  142.     watchCursor                    = 4;
  143.  
  144.     kQDGrafVerbFrame            = 0;
  145.     kQDGrafVerbPaint            = 1;
  146.     kQDGrafVerbErase            = 2;
  147.     kQDGrafVerbInvert            = 3;
  148.     kQDGrafVerbFill                = 4;
  149.  
  150. {$IFC OLDROUTINENAMES }
  151.     frame                        = 0;
  152.     paint                        = 1;
  153.     erase                        = 2;
  154.     invert                        = 3;
  155.     fill                        = 4;
  156.  
  157. {$ENDC}  {OLDROUTINENAMES}
  158.  
  159.  
  160. TYPE
  161.     GrafVerb                            = SInt8;
  162.  
  163. CONST
  164.     chunky                        = 0;
  165.     chunkyPlanar                = 1;
  166.     planar                        = 2;
  167.  
  168.  
  169. TYPE
  170.     PixelType                            = SInt8;
  171.     Bits16                                = ARRAY [0..15] OF INTEGER;
  172.  
  173. {**************   IMPORTANT NOTE REGARDING Pattern  **************************************
  174.    Patterns were originally defined as:
  175.    
  176.         C:             typedef unsigned char Pattern[8];
  177.         Pascal:        Pattern = PACKED ARRAY [0..7] OF 0..255;
  178.         
  179.    The old array definition of Pattern would cause 68000 based CPU's to crash in certain circum-
  180.    stances. The new struct definition is safe, but may require source code changes to compile.
  181.     
  182. ********************************************************************************************}
  183.     PatternPtr = ^Pattern;
  184.     Pattern = RECORD
  185.         pat:                    PACKED ARRAY [0..7] OF UInt8;
  186.     END;
  187.  
  188. {
  189.  ConstPatternParam is no longer needed.  It was first created when Pattern was an array.
  190.  Now that Pattern is a struct, it is more straight forward to just add the "const" qualifier
  191.  on the parameter type (e.g. "const Pattern * pat" instead of "ConstPatternParam pat").
  192. }
  193.     PatPtr                                = ^Pattern;
  194.     PatHandle                            = ^PatPtr;
  195.     QDByte                                = SignedByte;
  196.     QDPtr                                = Ptr;
  197.     QDHandle                            = Handle;
  198.     QDErr                                = INTEGER;
  199.  
  200. CONST
  201.     singleDevicesBit            = 0;
  202.     dontMatchSeedsBit            = 1;
  203.     allDevicesBit                = 2;
  204.  
  205.     singleDevices                = $01;
  206.     dontMatchSeeds                = $02;
  207.     allDevices                    = $04;
  208.  
  209.  
  210. TYPE
  211.     DeviceLoopFlags                        = UInt32;
  212.     BitMapPtr = ^BitMap;
  213.     BitMap = RECORD
  214.         baseAddr:                Ptr;
  215.         rowBytes:                INTEGER;
  216.         bounds:                    Rect;
  217.     END;
  218.  
  219.     BitMapHandle                        = ^BitMapPtr;
  220.     CursorPtr = ^Cursor;
  221.     Cursor = RECORD
  222.         data:                    Bits16;
  223.         mask:                    Bits16;
  224.         hotSpot:                Point;
  225.     END;
  226.  
  227.     CursPtr                                = ^Cursor;
  228.     CursHandle                            = ^CursPtr;
  229.     PenStatePtr = ^PenState;
  230.     PenState = RECORD
  231.         pnLoc:                    Point;
  232.         pnSize:                    Point;
  233.         pnMode:                    INTEGER;
  234.         pnPat:                    Pattern;
  235.     END;
  236.  
  237.     MacRegionPtr = ^MacRegion;
  238.     MacRegion = RECORD
  239.         rgnSize:                UInt16;                                    { size in bytes }
  240.         rgnBBox:                Rect;                                    { enclosing rectangle }
  241.     END;
  242.  
  243. {
  244.     The type name "Region" has a name space collision on Win32.
  245.     Use MacRegion to be cross-platfrom safe.
  246. }
  247. {$IFC TARGET_OS_MAC }
  248.     Region                                = MacRegion;
  249.     RegionPtr                             = ^Region;
  250. {$ENDC}  {TARGET_OS_MAC}
  251.  
  252.     RgnPtr                                = ^MacRegion;
  253.     RgnHandle                            = ^RgnPtr;
  254.     PicturePtr = ^Picture;
  255.     Picture = RECORD
  256.         picSize:                INTEGER;
  257.         picFrame:                Rect;
  258.     END;
  259.  
  260.     PicPtr                                = ^Picture;
  261.     PicHandle                            = ^PicPtr;
  262.     MacPolygonPtr = ^MacPolygon;
  263.     MacPolygon = RECORD
  264.         polySize:                INTEGER;
  265.         polyBBox:                Rect;
  266.         polyPoints:                ARRAY [0..0] OF Point;
  267.     END;
  268.  
  269. {
  270.     The type name "Polygon" has a name space collision on Win32.
  271.     Use MacPolygon to be cross-platfrom safe.
  272. }
  273. {$IFC TARGET_OS_MAC }
  274.     Polygon                                = MacPolygon;
  275.     PolygonPtr                             = ^Polygon;
  276. {$ENDC}  {TARGET_OS_MAC}
  277.  
  278.     PolyPtr                                = ^MacPolygon;
  279.     PolyHandle                            = ^PolyPtr;
  280. {$IFC TYPED_FUNCTION_POINTERS}
  281.     QDTextProcPtr = PROCEDURE(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point);
  282. {$ELSEC}
  283.     QDTextProcPtr = ProcPtr;
  284. {$ENDC}
  285.  
  286. {$IFC TYPED_FUNCTION_POINTERS}
  287.     QDLineProcPtr = PROCEDURE(newPt: Point);
  288. {$ELSEC}
  289.     QDLineProcPtr = ProcPtr;
  290. {$ENDC}
  291.  
  292. {$IFC TYPED_FUNCTION_POINTERS}
  293.     QDRectProcPtr = PROCEDURE(verb: GrafVerb; VAR r: Rect);
  294. {$ELSEC}
  295.     QDRectProcPtr = ProcPtr;
  296. {$ENDC}
  297.  
  298. {$IFC TYPED_FUNCTION_POINTERS}
  299.     QDRRectProcPtr = PROCEDURE(verb: GrafVerb; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  300. {$ELSEC}
  301.     QDRRectProcPtr = ProcPtr;
  302. {$ENDC}
  303.  
  304. {$IFC TYPED_FUNCTION_POINTERS}
  305.     QDOvalProcPtr = PROCEDURE(verb: GrafVerb; VAR r: Rect);
  306. {$ELSEC}
  307.     QDOvalProcPtr = ProcPtr;
  308. {$ENDC}
  309.  
  310. {$IFC TYPED_FUNCTION_POINTERS}
  311.     QDArcProcPtr = PROCEDURE(verb: GrafVerb; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  312. {$ELSEC}
  313.     QDArcProcPtr = ProcPtr;
  314. {$ENDC}
  315.  
  316. {$IFC TYPED_FUNCTION_POINTERS}
  317.     QDPolyProcPtr = PROCEDURE(verb: GrafVerb; poly: PolyHandle);
  318. {$ELSEC}
  319.     QDPolyProcPtr = ProcPtr;
  320. {$ENDC}
  321.  
  322. {$IFC TYPED_FUNCTION_POINTERS}
  323.     QDRgnProcPtr = PROCEDURE(verb: GrafVerb; rgn: RgnHandle);
  324. {$ELSEC}
  325.     QDRgnProcPtr = ProcPtr;
  326. {$ENDC}
  327.  
  328. {$IFC TYPED_FUNCTION_POINTERS}
  329.     QDBitsProcPtr = PROCEDURE(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  330. {$ELSEC}
  331.     QDBitsProcPtr = ProcPtr;
  332. {$ENDC}
  333.  
  334. {$IFC TYPED_FUNCTION_POINTERS}
  335.     QDCommentProcPtr = PROCEDURE(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  336. {$ELSEC}
  337.     QDCommentProcPtr = ProcPtr;
  338. {$ENDC}
  339.  
  340. {$IFC TYPED_FUNCTION_POINTERS}
  341.     QDTxMeasProcPtr = FUNCTION(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo): INTEGER;
  342. {$ELSEC}
  343.     QDTxMeasProcPtr = ProcPtr;
  344. {$ENDC}
  345.  
  346. {$IFC TYPED_FUNCTION_POINTERS}
  347.     QDGetPicProcPtr = PROCEDURE(dataPtr: Ptr; byteCount: INTEGER);
  348. {$ELSEC}
  349.     QDGetPicProcPtr = ProcPtr;
  350. {$ENDC}
  351.  
  352. {$IFC TYPED_FUNCTION_POINTERS}
  353.     QDPutPicProcPtr = PROCEDURE(dataPtr: Ptr; byteCount: INTEGER);
  354. {$ELSEC}
  355.     QDPutPicProcPtr = ProcPtr;
  356. {$ENDC}
  357.  
  358. {$IFC TYPED_FUNCTION_POINTERS}
  359.     QDOpcodeProcPtr = PROCEDURE(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER);
  360. {$ELSEC}
  361.     QDOpcodeProcPtr = ProcPtr;
  362. {$ENDC}
  363.  
  364. {$IFC TYPED_FUNCTION_POINTERS}
  365.     QDStdGlyphsProcPtr = FUNCTION(dataStream: UNIV Ptr; size: ByteCount): OSStatus; C;
  366. {$ELSEC}
  367.     QDStdGlyphsProcPtr = ProcPtr;
  368. {$ENDC}
  369.  
  370. {$IFC TYPED_FUNCTION_POINTERS}
  371.     QDJShieldCursorProcPtr = PROCEDURE(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  372. {$ELSEC}
  373.     QDJShieldCursorProcPtr = ProcPtr;
  374. {$ENDC}
  375.  
  376.     QDTextUPP = UniversalProcPtr;
  377.     QDLineUPP = UniversalProcPtr;
  378.     QDRectUPP = UniversalProcPtr;
  379.     QDRRectUPP = UniversalProcPtr;
  380.     QDOvalUPP = UniversalProcPtr;
  381.     QDArcUPP = UniversalProcPtr;
  382.     QDPolyUPP = UniversalProcPtr;
  383.     QDRgnUPP = UniversalProcPtr;
  384.     QDBitsUPP = UniversalProcPtr;
  385.     QDCommentUPP = UniversalProcPtr;
  386.     QDTxMeasUPP = UniversalProcPtr;
  387.     QDGetPicUPP = UniversalProcPtr;
  388.     QDPutPicUPP = UniversalProcPtr;
  389.     QDOpcodeUPP = UniversalProcPtr;
  390.     QDStdGlyphsUPP = UniversalProcPtr;
  391.     QDJShieldCursorUPP = UniversalProcPtr;
  392.     QDProcsPtr = ^QDProcs;
  393.     QDProcs = RECORD
  394.         textProc:                QDTextUPP;
  395.         lineProc:                QDLineUPP;
  396.         rectProc:                QDRectUPP;
  397.         rRectProc:                QDRRectUPP;
  398.         ovalProc:                QDOvalUPP;
  399.         arcProc:                QDArcUPP;
  400.         polyProc:                QDPolyUPP;
  401.         rgnProc:                QDRgnUPP;
  402.         bitsProc:                QDBitsUPP;
  403.         commentProc:            QDCommentUPP;
  404.         txMeasProc:                QDTxMeasUPP;
  405.         getPicProc:                QDGetPicUPP;
  406.         putPicProc:                QDPutPicUPP;
  407.     END;
  408.  
  409.  
  410. CONST
  411.     uppQDTextProcInfo = $00003F80;
  412.     uppQDLineProcInfo = $000000C0;
  413.     uppQDRectProcInfo = $00000340;
  414.     uppQDRRectProcInfo = $00002B40;
  415.     uppQDOvalProcInfo = $00000340;
  416.     uppQDArcProcInfo = $00002B40;
  417.     uppQDPolyProcInfo = $00000340;
  418.     uppQDRgnProcInfo = $00000340;
  419.     uppQDBitsProcInfo = $0000EFC0;
  420.     uppQDCommentProcInfo = $00000E80;
  421.     uppQDTxMeasProcInfo = $0000FFA0;
  422.     uppQDGetPicProcInfo = $000002C0;
  423.     uppQDPutPicProcInfo = $000002C0;
  424.     uppQDOpcodeProcInfo = $00002BC0;
  425.     uppQDStdGlyphsProcInfo = $000003F1;
  426.     uppQDJShieldCursorProcInfo = $00002A80;
  427.  
  428. FUNCTION NewQDTextProc(userRoutine: QDTextProcPtr): QDTextUPP;
  429.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  430.     INLINE $2E9F;
  431.     {$ENDC}
  432.  
  433. FUNCTION NewQDLineProc(userRoutine: QDLineProcPtr): QDLineUPP;
  434.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  435.     INLINE $2E9F;
  436.     {$ENDC}
  437.  
  438. FUNCTION NewQDRectProc(userRoutine: QDRectProcPtr): QDRectUPP;
  439.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  440.     INLINE $2E9F;
  441.     {$ENDC}
  442.  
  443. FUNCTION NewQDRRectProc(userRoutine: QDRRectProcPtr): QDRRectUPP;
  444.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  445.     INLINE $2E9F;
  446.     {$ENDC}
  447.  
  448. FUNCTION NewQDOvalProc(userRoutine: QDOvalProcPtr): QDOvalUPP;
  449.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  450.     INLINE $2E9F;
  451.     {$ENDC}
  452.  
  453. FUNCTION NewQDArcProc(userRoutine: QDArcProcPtr): QDArcUPP;
  454.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  455.     INLINE $2E9F;
  456.     {$ENDC}
  457.  
  458. FUNCTION NewQDPolyProc(userRoutine: QDPolyProcPtr): QDPolyUPP;
  459.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  460.     INLINE $2E9F;
  461.     {$ENDC}
  462.  
  463. FUNCTION NewQDRgnProc(userRoutine: QDRgnProcPtr): QDRgnUPP;
  464.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  465.     INLINE $2E9F;
  466.     {$ENDC}
  467.  
  468. FUNCTION NewQDBitsProc(userRoutine: QDBitsProcPtr): QDBitsUPP;
  469.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  470.     INLINE $2E9F;
  471.     {$ENDC}
  472.  
  473. FUNCTION NewQDCommentProc(userRoutine: QDCommentProcPtr): QDCommentUPP;
  474.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  475.     INLINE $2E9F;
  476.     {$ENDC}
  477.  
  478. FUNCTION NewQDTxMeasProc(userRoutine: QDTxMeasProcPtr): QDTxMeasUPP;
  479.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  480.     INLINE $2E9F;
  481.     {$ENDC}
  482.  
  483. FUNCTION NewQDGetPicProc(userRoutine: QDGetPicProcPtr): QDGetPicUPP;
  484.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  485.     INLINE $2E9F;
  486.     {$ENDC}
  487.  
  488. FUNCTION NewQDPutPicProc(userRoutine: QDPutPicProcPtr): QDPutPicUPP;
  489.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  490.     INLINE $2E9F;
  491.     {$ENDC}
  492.  
  493. FUNCTION NewQDOpcodeProc(userRoutine: QDOpcodeProcPtr): QDOpcodeUPP;
  494.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  495.     INLINE $2E9F;
  496.     {$ENDC}
  497.  
  498. FUNCTION NewQDStdGlyphsProc(userRoutine: QDStdGlyphsProcPtr): QDStdGlyphsUPP;
  499.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  500.     INLINE $2E9F;
  501.     {$ENDC}
  502.  
  503. FUNCTION NewQDJShieldCursorProc(userRoutine: QDJShieldCursorProcPtr): QDJShieldCursorUPP;
  504.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  505.     INLINE $2E9F;
  506.     {$ENDC}
  507.  
  508. PROCEDURE CallQDTextProc(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point; userRoutine: QDTextUPP);
  509.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  510.     INLINE $205F, $4E90;
  511.     {$ENDC}
  512.  
  513. PROCEDURE CallQDLineProc(newPt: Point; userRoutine: QDLineUPP);
  514.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  515.     INLINE $205F, $4E90;
  516.     {$ENDC}
  517.  
  518. PROCEDURE CallQDRectProc(verb: GrafVerb; VAR r: Rect; userRoutine: QDRectUPP);
  519.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  520.     INLINE $205F, $4E90;
  521.     {$ENDC}
  522.  
  523. PROCEDURE CallQDRRectProc(verb: GrafVerb; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; userRoutine: QDRRectUPP);
  524.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  525.     INLINE $205F, $4E90;
  526.     {$ENDC}
  527.  
  528. PROCEDURE CallQDOvalProc(verb: GrafVerb; VAR r: Rect; userRoutine: QDOvalUPP);
  529.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  530.     INLINE $205F, $4E90;
  531.     {$ENDC}
  532.  
  533. PROCEDURE CallQDArcProc(verb: GrafVerb; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; userRoutine: QDArcUPP);
  534.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  535.     INLINE $205F, $4E90;
  536.     {$ENDC}
  537.  
  538. PROCEDURE CallQDPolyProc(verb: GrafVerb; poly: PolyHandle; userRoutine: QDPolyUPP);
  539.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  540.     INLINE $205F, $4E90;
  541.     {$ENDC}
  542.  
  543. PROCEDURE CallQDRgnProc(verb: GrafVerb; rgn: RgnHandle; userRoutine: QDRgnUPP);
  544.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  545.     INLINE $205F, $4E90;
  546.     {$ENDC}
  547.  
  548. PROCEDURE CallQDBitsProc(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle; userRoutine: QDBitsUPP);
  549.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  550.     INLINE $205F, $4E90;
  551.     {$ENDC}
  552.  
  553. PROCEDURE CallQDCommentProc(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle; userRoutine: QDCommentUPP);
  554.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  555.     INLINE $205F, $4E90;
  556.     {$ENDC}
  557.  
  558. FUNCTION CallQDTxMeasProc(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo; userRoutine: QDTxMeasUPP): INTEGER;
  559.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  560.     INLINE $205F, $4E90;
  561.     {$ENDC}
  562.  
  563. PROCEDURE CallQDGetPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDGetPicUPP);
  564.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  565.     INLINE $205F, $4E90;
  566.     {$ENDC}
  567.  
  568. PROCEDURE CallQDPutPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDPutPicUPP);
  569.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  570.     INLINE $205F, $4E90;
  571.     {$ENDC}
  572.  
  573. PROCEDURE CallQDOpcodeProc(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER; userRoutine: QDOpcodeUPP);
  574.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  575.     INLINE $205F, $4E90;
  576.     {$ENDC}
  577.  
  578. FUNCTION CallQDStdGlyphsProc(dataStream: UNIV Ptr; size: ByteCount; userRoutine: QDStdGlyphsUPP): OSStatus;
  579.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  580.     {To be implemented:  Glue to move parameters into registers.}
  581.     {$ENDC}
  582.  
  583. PROCEDURE CallQDJShieldCursorProc(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER; userRoutine: QDJShieldCursorUPP);
  584.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  585.     INLINE $205F, $4E90;
  586.     {$ENDC}
  587.  
  588.  
  589.  
  590. TYPE
  591.     GrafPortPtr = ^GrafPort;
  592.     GrafPort = RECORD
  593.         device:                    INTEGER;
  594.         portBits:                BitMap;
  595.         portRect:                Rect;
  596.         visRgn:                    RgnHandle;
  597.         clipRgn:                RgnHandle;
  598.         bkPat:                    Pattern;
  599.         fillPat:                Pattern;
  600.         pnLoc:                    Point;
  601.         pnSize:                    Point;
  602.         pnMode:                    INTEGER;
  603.         pnPat:                    Pattern;
  604.         pnVis:                    INTEGER;
  605.         txFont:                    INTEGER;
  606.         txFace:                    StyleField;                                { StyleField occupies 16-bits, but only first 8-bits are used }
  607.         txMode:                    INTEGER;
  608.         txSize:                    INTEGER;
  609.         spExtra:                Fixed;
  610.         fgColor:                LONGINT;
  611.         bkColor:                LONGINT;
  612.         colrBit:                INTEGER;
  613.         patStretch:                INTEGER;
  614.         picSave:                Handle;
  615.         rgnSave:                Handle;
  616.         polySave:                Handle;
  617.         grafProcs:                QDProcsPtr;
  618.     END;
  619.  
  620.     GrafPtr                                = ^GrafPort;
  621.  
  622. {
  623.  *    This set of definitions "belongs" in Windows.
  624.  *    But, there is a circularity in the headers where Windows includes Controls and
  625.  *    Controls includes Windows. To break the circle, the information
  626.  *    needed by Controls is moved from Windows to Quickdraw.
  627.  }
  628.     WindowPtr                            = GrafPtr;
  629.     DialogPtr                            = WindowPtr;
  630.     WindowRef                            = WindowPtr;
  631. {  DragConstraint constants to pass to DragGray,DragTheRgn, or ConstrainedDragRgn }
  632.     DragConstraint                        = UInt16;
  633.  
  634. CONST
  635.     kNoConstraint                = 0;
  636.     kVerticalConstraint            = 1;
  637.     kHorizontalConstraint        = 2;
  638.  
  639.  
  640.  
  641. TYPE
  642. {$IFC TYPED_FUNCTION_POINTERS}
  643.     DragGrayRgnProcPtr = PROCEDURE;
  644. {$ELSEC}
  645.     DragGrayRgnProcPtr = ProcPtr;
  646. {$ENDC}
  647.  
  648. {
  649.  *    Here ends the list of things that "belong" in Windows.
  650.  }
  651.  
  652.  
  653.     RGBColorPtr = ^RGBColor;
  654.     RGBColor = RECORD
  655.         red:                    UInt16;                                    { magnitude of red component }
  656.         green:                    UInt16;                                    { magnitude of green component }
  657.         blue:                    UInt16;                                    { magnitude of blue component }
  658.     END;
  659.  
  660.     RGBColorHdl                            = ^RGBColorPtr;
  661. {$IFC TYPED_FUNCTION_POINTERS}
  662.     ColorSearchProcPtr = FUNCTION(VAR rgb: RGBColor; VAR position: LONGINT): BOOLEAN;
  663. {$ELSEC}
  664.     ColorSearchProcPtr = ProcPtr;
  665. {$ENDC}
  666.  
  667. {$IFC TYPED_FUNCTION_POINTERS}
  668.     ColorComplementProcPtr = FUNCTION(VAR rgb: RGBColor): BOOLEAN;
  669. {$ELSEC}
  670.     ColorComplementProcPtr = ProcPtr;
  671. {$ENDC}
  672.  
  673.     DragGrayRgnUPP = UniversalProcPtr;
  674.     ColorSearchUPP = UniversalProcPtr;
  675.     ColorComplementUPP = UniversalProcPtr;
  676.  
  677. CONST
  678.     uppDragGrayRgnProcInfo = $00000000;
  679.     uppColorSearchProcInfo = $000003D0;
  680.     uppColorComplementProcInfo = $000000D0;
  681.  
  682. FUNCTION NewDragGrayRgnProc(userRoutine: DragGrayRgnProcPtr): DragGrayRgnUPP;
  683.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  684.     INLINE $2E9F;
  685.     {$ENDC}
  686.  
  687. FUNCTION NewColorSearchProc(userRoutine: ColorSearchProcPtr): ColorSearchUPP;
  688.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  689.     INLINE $2E9F;
  690.     {$ENDC}
  691.  
  692. FUNCTION NewColorComplementProc(userRoutine: ColorComplementProcPtr): ColorComplementUPP;
  693.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  694.     INLINE $2E9F;
  695.     {$ENDC}
  696.  
  697. PROCEDURE CallDragGrayRgnProc(userRoutine: DragGrayRgnUPP);
  698.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  699.     INLINE $205F, $4E90;
  700.     {$ENDC}
  701.  
  702. FUNCTION CallColorSearchProc(VAR rgb: RGBColor; VAR position: LONGINT; userRoutine: ColorSearchUPP): BOOLEAN;
  703.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  704.     INLINE $205F, $4E90;
  705.     {$ENDC}
  706.  
  707. FUNCTION CallColorComplementProc(VAR rgb: RGBColor; userRoutine: ColorComplementUPP): BOOLEAN;
  708.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  709.     INLINE $205F, $4E90;
  710.     {$ENDC}
  711.  
  712. TYPE
  713.     ColorSpecPtr = ^ColorSpec;
  714.     ColorSpec = RECORD
  715.         value:                    INTEGER;                                { index or other value }
  716.         rgb:                    RGBColor;                                { true color }
  717.     END;
  718.  
  719.     CSpecArray                            = ARRAY [0..0] OF ColorSpec;
  720.     ColorTablePtr = ^ColorTable;
  721.     ColorTable = RECORD
  722.         ctSeed:                    LONGINT;                                { unique identifier for table }
  723.         ctFlags:                INTEGER;                                { high bit: 0 = PixMap; 1 = device }
  724.         ctSize:                    INTEGER;                                { number of entries in CTTable }
  725.         ctTable:                CSpecArray;                                { array [0..0] of ColorSpec }
  726.     END;
  727.  
  728.     CTabPtr                                = ^ColorTable;
  729.     CTabHandle                            = ^CTabPtr;
  730.     xColorSpecPtr = ^xColorSpec;
  731.     xColorSpec = RECORD
  732.         value:                    INTEGER;                                { index or other value }
  733.         rgb:                    RGBColor;                                { true color }
  734.         xalpha:                    INTEGER;
  735.     END;
  736.  
  737.     xCSpecArray                            = ARRAY [0..0] OF xColorSpec;
  738.     MatchRecPtr = ^MatchRec;
  739.     MatchRec = RECORD
  740.         red:                    UInt16;
  741.         green:                    UInt16;
  742.         blue:                    UInt16;
  743.         matchData:                LONGINT;
  744.     END;
  745.  
  746. {
  747.     QuickTime 3.0 makes PixMap data structure available on non-Mac OS's.
  748.     In order to implement PixMap in these alternate environments, the PixMap
  749.     had to be extended. The pmReserved field was changed to pmExt which is
  750.     a Handle to extra info.  The planeBytes field was changed to pixelFormat.
  751. }
  752. {$IFC UNDEFINED OLDPIXMAPSTRUCT }
  753. {$IFC TARGET_OS_MAC }
  754. {$SETC OLDPIXMAPSTRUCT := 1 }
  755. {$ELSEC}
  756. {$SETC OLDPIXMAPSTRUCT := 0 }
  757. {$ENDC}
  758. {$ENDC}
  759.  
  760. {  pixel formats }
  761.  
  762. CONST
  763.     k1MonochromePixelFormat        = $00000001;                    {  1 bit indexed }
  764.     k2IndexedPixelFormat        = $00000002;                    {  2 bit indexed }
  765.     k4IndexedPixelFormat        = $00000004;                    {  4 bit indexed }
  766.     k8IndexedPixelFormat        = $00000008;                    {  8 bit indexed }
  767.     k16BE555PixelFormat            = $00000010;                    {  16 bit BE rgb 555 (Mac) }
  768.     k24RGBPixelFormat            = $00000018;                    {  24 bit rgb  }
  769.     k32ARGBPixelFormat            = $00000020;                    {  32 bit argb    (Mac) }
  770.     k1IndexedGrayPixelFormat    = $00000021;                    {  1 bit indexed gray }
  771.     k2IndexedGrayPixelFormat    = $00000022;                    {  2 bit indexed gray }
  772.     k4IndexedGrayPixelFormat    = $00000024;                    {  4 bit indexed gray }
  773.     k8IndexedGrayPixelFormat    = $00000028;                    {  8 bit indexed gray }
  774.  
  775.  
  776. {  values for PixMap.pixelFormat }
  777.     k16LE555PixelFormat            = 'L555';                        {  16 bit LE rgb 555 (PC) }
  778.     k16BE565PixelFormat            = 'B565';                        {  16 bit BE rgb 565 }
  779.     k16LE565PixelFormat            = 'L565';                        {  16 bit LE rgb 565 }
  780.     k24BGRPixelFormat            = '24BG';                        {  24 bit bgr  }
  781.     k32BGRAPixelFormat            = 'BGRA';                        {  32 bit bgra    (Matrox) }
  782.     k32ABGRPixelFormat            = 'ABGR';                        {  32 bit abgr     }
  783.     k32RGBAPixelFormat            = 'RGBA';                        {  32 bit rgba     }
  784.     kYUVSPixelFormat            = 'yuvs';                        {  YUV 4:2:2 byte ordering 16-unsigned = 'YUY2' }
  785.     kYUVUPixelFormat            = 'yuvu';                        {  YUV 4:2:2 byte ordering 16-signed }
  786.     kYVU9PixelFormat            = 'YVU9';                        {  YVU9 Planar    9 }
  787.     kYUV411PixelFormat            = 'Y411';                        {  YUV 4:1:1 Interleaved    16 }
  788.     kYVYU422PixelFormat            = 'YVYU';                        {  YVYU 4:2:2 byte ordering    16 }
  789.     kUYVY422PixelFormat            = 'UYVY';                        {  UYVY 4:2:2 byte ordering    16 }
  790.     kYUV211PixelFormat            = 'Y211';                        {  YUV 2:1:1 Packed    8 }
  791.  
  792.  
  793. {$IFC NOT OLDPIXMAPSTRUCT }
  794.  
  795. TYPE
  796.     PixMapExtensionPtr = ^PixMapExtension;
  797.     PixMapExtension = RECORD
  798.         extSize:                LONGINT;                                { size of struct, duh! }
  799.         pmBits:                    UInt32;                                    { pixmap attributes bitfield }
  800.         pmGD:                    Ptr;                                    { this is a GDHandle }
  801.         pmSeed:                    LONGINT;
  802.         reserved0:                UInt32;                                    { reserved for future use }
  803.         reserved1:                UInt32;
  804.         reserved2:                UInt32;
  805.     END;
  806.  
  807.     PixMapExtPtr                        = ^PixMapExtension;
  808.     PixMapExtHandle                        = ^PixMapExtPtr;
  809. {$ENDC}
  810.  
  811.  
  812. TYPE
  813.     PixMapPtr = ^PixMap;
  814.     PixMap = RECORD
  815.         baseAddr:                Ptr;                                    { pointer to pixels }
  816.         rowBytes:                INTEGER;                                { offset to next line }
  817.         bounds:                    Rect;                                    { encloses bitmap }
  818.         pmVersion:                INTEGER;                                { pixMap version number }
  819.         packType:                INTEGER;                                { defines packing format }
  820.         packSize:                LONGINT;                                { length of pixel data }
  821.         hRes:                    Fixed;                                    { horiz. resolution (ppi) }
  822.         vRes:                    Fixed;                                    { vert. resolution (ppi) }
  823.         pixelType:                INTEGER;                                { defines pixel type }
  824.         pixelSize:                INTEGER;                                { # bits in pixel }
  825.         cmpCount:                INTEGER;                                { # components in pixel }
  826.         cmpSize:                INTEGER;                                { # bits per component }
  827.         planeBytes:                LONGINT;                                { offset to next plane }
  828.         pmTable:                CTabHandle;                                { color map for this pixMap }
  829.         pmReserved:                LONGINT;
  830.     END;
  831.  
  832.     PixMapHandle                        = ^PixMapPtr;
  833.     PixPatPtr = ^PixPat;
  834.     PixPat = RECORD
  835.         patType:                INTEGER;                                { type of pattern }
  836.         patMap:                    PixMapHandle;                            { the pattern's pixMap }
  837.         patData:                Handle;                                    { pixmap's data }
  838.         patXData:                Handle;                                    { expanded Pattern data }
  839.         patXValid:                INTEGER;                                { flags whether expanded Pattern valid }
  840.         patXMap:                Handle;                                    { Handle to expanded Pattern data }
  841.         pat1Data:                Pattern;                                { old-Style pattern/RGB color }
  842.     END;
  843.  
  844.     PixPatHandle                        = ^PixPatPtr;
  845.     CCrsrPtr = ^CCrsr;
  846.     CCrsr = RECORD
  847.         crsrType:                INTEGER;                                { type of cursor }
  848.         crsrMap:                PixMapHandle;                            { the cursor's pixmap }
  849.         crsrData:                Handle;                                    { cursor's data }
  850.         crsrXData:                Handle;                                    { expanded cursor data }
  851.         crsrXValid:                INTEGER;                                { depth of expanded data (0 if none) }
  852.         crsrXHandle:            Handle;                                    { future use }
  853.         crsr1Data:                Bits16;                                    { one-bit cursor }
  854.         crsrMask:                Bits16;                                    { cursor's mask }
  855.         crsrHotSpot:            Point;                                    { cursor's hotspot }
  856.         crsrXTable:                LONGINT;                                { private }
  857.         crsrID:                    LONGINT;                                { private }
  858.     END;
  859.  
  860.     CCrsrHandle                            = ^CCrsrPtr;
  861. {$IFC OLDROUTINELOCATIONS }
  862.     CIconPtr = ^CIcon;
  863.     CIcon = RECORD
  864.         iconPMap:                PixMap;                                    { the icon's pixMap }
  865.         iconMask:                BitMap;                                    { the icon's mask }
  866.         iconBMap:                BitMap;                                    { the icon's bitMap }
  867.         iconData:                Handle;                                    { the icon's data }
  868.         iconMaskData:            ARRAY [0..0] OF INTEGER;                { icon's mask and BitMap data }
  869.     END;
  870.  
  871.     CIconHandle                            = ^CIconPtr;
  872. {$ENDC}  {OLDROUTINELOCATIONS}
  873.  
  874.     GammaTblPtr = ^GammaTbl;
  875.     GammaTbl = RECORD
  876.         gVersion:                INTEGER;                                { gamma version number }
  877.         gType:                    INTEGER;                                { gamma data type }
  878.         gFormulaSize:            INTEGER;                                { Formula data size }
  879.         gChanCnt:                INTEGER;                                { number of channels of data }
  880.         gDataCnt:                INTEGER;                                { number of values/channel }
  881.         gDataWidth:                INTEGER;                                { bits/corrected value (data packed to next larger byte size) }
  882.         gFormulaData:            ARRAY [0..0] OF INTEGER;                { data for formulas followed by gamma values }
  883.     END;
  884.  
  885.     GammaTblHandle                        = ^GammaTblPtr;
  886.     ITabPtr = ^ITab;
  887.     ITab = RECORD
  888.         iTabSeed:                LONGINT;                                { copy of CTSeed from source CTable }
  889.         iTabRes:                INTEGER;                                { bits/channel resolution of iTable }
  890.         iTTable:                SInt8;                                    { byte colortable index values }
  891.     END;
  892.  
  893.     ITabHandle                            = ^ITabPtr;
  894.     SProcRecPtr = ^SProcRec;
  895.     SProcRec = RECORD
  896.         nxtSrch:                Handle;                                    { SProcHndl Handle to next SProcRec }
  897.         srchProc:                ColorSearchUPP;                            { search procedure proc ptr }
  898.     END;
  899.  
  900.     SProcPtr                            = ^SProcRec;
  901.     SProcHndl                            = ^SProcPtr;
  902.     CProcRecPtr = ^CProcRec;
  903.     CProcRec = RECORD
  904.         nxtComp:                Handle;                                    { CProcHndl Handle to next CProcRec }
  905.         compProc:                ColorComplementUPP;                        { complement procedure proc ptr }
  906.     END;
  907.  
  908.     CProcPtr                            = ^CProcRec;
  909.     CProcHndl                            = ^CProcPtr;
  910. {
  911.     QuickTime 3.0 makes GDevice data structure available on non-Mac OS's.
  912.     In order to implement GDevice in these alternate environments, the GDevice
  913.     had to be extended. The gdReserved field was changed to gdExt which is
  914.     a Handle to extra info.  
  915. }
  916. {$IFC UNDEFINED OLDGDEVICESTRUCT }
  917. {$IFC TARGET_OS_MAC }
  918. {$SETC OLDGDEVICESTRUCT := 1 }
  919. {$ELSEC}
  920. {$SETC OLDGDEVICESTRUCT := 0 }
  921. {$ENDC}
  922. {$ENDC}
  923.  
  924.     GDevicePtr = ^GDevice;
  925.     GDevice = RECORD
  926.         gdRefNum:                INTEGER;                                { driver's unit number }
  927.         gdID:                    INTEGER;                                { client ID for search procs }
  928.         gdType:                    INTEGER;                                { fixed/CLUT/direct }
  929.         gdITable:                ITabHandle;                                { Handle to inverse lookup table }
  930.         gdResPref:                INTEGER;                                { preferred resolution of GDITable }
  931.         gdSearchProc:            SProcHndl;                                { search proc list head }
  932.         gdCompProc:                CProcHndl;                                { complement proc list }
  933.         gdFlags:                INTEGER;                                { grafDevice flags word }
  934.         gdPMap:                    PixMapHandle;                            { describing pixMap }
  935.         gdRefCon:                LONGINT;                                { reference value }
  936.         gdNextGD:                Handle;                                    { GDHandle Handle of next gDevice }
  937.         gdRect:                    Rect;                                    {  device's bounds in global coordinates }
  938.         gdMode:                    LONGINT;                                { device's current mode }
  939.         gdCCBytes:                INTEGER;                                { depth of expanded cursor data }
  940.         gdCCDepth:                INTEGER;                                { depth of expanded cursor data }
  941.         gdCCXData:                Handle;                                    { Handle to cursor's expanded data }
  942.         gdCCXMask:                Handle;                                    { Handle to cursor's expanded mask }
  943.         gdReserved:                LONGINT;                                { future use. MUST BE 0 }
  944.     END;
  945.  
  946.     GDPtr                                = ^GDevice;
  947.     GDHandle                            = ^GDPtr;
  948.     GrafVars = RECORD
  949.         rgbOpColor:                RGBColor;                                { color for addPin  subPin and average }
  950.         rgbHiliteColor:            RGBColor;                                { color for hiliting }
  951.         pmFgColor:                Handle;                                    { palette Handle for foreground color }
  952.         pmFgIndex:                INTEGER;                                { index value for foreground }
  953.         pmBkColor:                Handle;                                    { palette Handle for background color }
  954.         pmBkIndex:                INTEGER;                                { index value for background }
  955.         pmFlags:                INTEGER;                                { flags for Palette Manager }
  956.     END;
  957.     GVarPtr                                = ^GrafVars;
  958.     GVarHandle                            = ^GVarPtr;
  959.     CQDProcsPtr = ^CQDProcs;
  960.     CQDProcs = RECORD
  961.         textProc:                QDTextUPP;
  962.         lineProc:                QDLineUPP;
  963.         rectProc:                QDRectUPP;
  964.         rRectProc:                QDRRectUPP;
  965.         ovalProc:                QDOvalUPP;
  966.         arcProc:                QDArcUPP;
  967.         polyProc:                QDPolyUPP;
  968.         rgnProc:                QDRgnUPP;
  969.         bitsProc:                QDBitsUPP;
  970.         commentProc:            QDCommentUPP;
  971.         txMeasProc:                QDTxMeasUPP;
  972.         getPicProc:                QDGetPicUPP;
  973.         putPicProc:                QDPutPicUPP;
  974.         opcodeProc:                QDOpcodeUPP;
  975.         newProc1:                UniversalProcPtr;                        {  this is the StdPix bottleneck -- see ImageCompression.h  }
  976.         glyphsProc:                QDStdGlyphsUPP;                            {  was newProc2; now used in Unicode text drawing  }
  977.         newProc3:                UniversalProcPtr;
  978.         newProc4:                UniversalProcPtr;
  979.         newProc5:                UniversalProcPtr;
  980.         newProc6:                UniversalProcPtr;
  981.     END;
  982.  
  983.     CGrafPortPtr = ^CGrafPort;
  984.     CGrafPort = RECORD
  985.         device:                    INTEGER;
  986.         portPixMap:                PixMapHandle;                            { port's pixel map }
  987.         portVersion:            INTEGER;                                { high 2 bits always set }
  988.         grafVars:                Handle;                                    { Handle to more fields }
  989.         chExtra:                INTEGER;                                { character extra }
  990.         pnLocHFrac:                INTEGER;                                { pen fraction }
  991.         portRect:                Rect;
  992.         visRgn:                    RgnHandle;
  993.         clipRgn:                RgnHandle;
  994.         bkPixPat:                PixPatHandle;                            { background pattern }
  995.         rgbFgColor:                RGBColor;                                { RGB components of fg }
  996.         rgbBkColor:                RGBColor;                                { RGB components of bk }
  997.         pnLoc:                    Point;
  998.         pnSize:                    Point;
  999.         pnMode:                    INTEGER;
  1000.         pnPixPat:                PixPatHandle;                            { pen's pattern }
  1001.         fillPixPat:                PixPatHandle;                            { fill pattern }
  1002.         pnVis:                    INTEGER;
  1003.         txFont:                    INTEGER;
  1004.         txFace:                    StyleField;                                { StyleField occupies 16-bits, but only first 8-bits are used }
  1005.         txMode:                    INTEGER;
  1006.         txSize:                    INTEGER;
  1007.         spExtra:                Fixed;
  1008.         fgColor:                LONGINT;
  1009.         bkColor:                LONGINT;
  1010.         colrBit:                INTEGER;
  1011.         patStretch:                INTEGER;
  1012.         picSave:                Handle;
  1013.         rgnSave:                Handle;
  1014.         polySave:                Handle;
  1015.         grafProcs:                CQDProcsPtr;
  1016.     END;
  1017.  
  1018.     CGrafPtr                            = ^CGrafPort;
  1019.     CWindowPtr                            = CGrafPtr;
  1020.     ReqListRecPtr = ^ReqListRec;
  1021.     ReqListRec = RECORD
  1022.         reqLSize:                INTEGER;                                { request list size }
  1023.         reqLData:                ARRAY [0..0] OF INTEGER;                { request list data }
  1024.     END;
  1025.  
  1026.     OpenCPicParamsPtr = ^OpenCPicParams;
  1027.     OpenCPicParams = RECORD
  1028.         srcRect:                Rect;
  1029.         hRes:                    Fixed;
  1030.         vRes:                    Fixed;
  1031.         version:                INTEGER;
  1032.         reserved1:                INTEGER;
  1033.         reserved2:                LONGINT;
  1034.     END;
  1035.  
  1036.  
  1037. CONST
  1038.     kCursorImageMajorVersion    = $0001;
  1039.     kCursorImageMinorVersion    = $0000;
  1040.  
  1041.  
  1042. TYPE
  1043.     CursorImageRecPtr = ^CursorImageRec;
  1044.     CursorImageRec = RECORD
  1045.         majorVersion:            UInt16;
  1046.         minorVersion:            UInt16;
  1047.         cursorPixMap:            PixMapHandle;
  1048.         cursorBitMask:            BitMapHandle;
  1049.     END;
  1050.  
  1051.     CursorImagePtr                        = ^CursorImageRec;
  1052. {$IFC TYPED_FUNCTION_POINTERS}
  1053.     DeviceLoopDrawingProcPtr = PROCEDURE(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT);
  1054. {$ELSEC}
  1055.     DeviceLoopDrawingProcPtr = ProcPtr;
  1056. {$ENDC}
  1057.  
  1058.     DeviceLoopDrawingUPP = UniversalProcPtr;
  1059.  
  1060. CONST
  1061.     uppDeviceLoopDrawingProcInfo = $00003E80;
  1062.  
  1063. FUNCTION NewDeviceLoopDrawingProc(userRoutine: DeviceLoopDrawingProcPtr): DeviceLoopDrawingUPP;
  1064.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1065.     INLINE $2E9F;
  1066.     {$ENDC}
  1067.  
  1068. PROCEDURE CallDeviceLoopDrawingProc(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT; userRoutine: DeviceLoopDrawingUPP);
  1069.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1070.     INLINE $205F, $4E90;
  1071.     {$ENDC}
  1072.  
  1073. TYPE
  1074.     QDGlobalsPtr = ^QDGlobals;
  1075.     QDGlobals = RECORD
  1076.         privates:                PACKED ARRAY [0..75] OF CHAR;
  1077.         randSeed:                LONGINT;
  1078.         screenBits:                BitMap;
  1079.         arrow:                    Cursor;
  1080.         dkGray:                    Pattern;
  1081.         ltGray:                    Pattern;
  1082.         gray:                    Pattern;
  1083.         black:                    Pattern;
  1084.         white:                    Pattern;
  1085.         thePort:                GrafPtr;
  1086.     END;
  1087.  
  1088.     QDGlobalsHdl                        = ^QDGlobalsPtr;
  1089.  
  1090. { To be in sync with the C interface to QuickDraw globals, pascal code must now }
  1091. { qualify the QuickDraw globals with “qd.” (e.g. InitGraf(@qd.thePort);  )       }
  1092. VAR
  1093.     {$PUSH}
  1094.     {$J+}
  1095.     qd: QDGlobals;
  1096.     {$POP}
  1097.  
  1098.  
  1099. PROCEDURE InitGraf(globalPtr: UNIV Ptr);
  1100.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1101.     INLINE $A86E;
  1102.     {$ENDC}
  1103. PROCEDURE OpenPort(port: GrafPtr);
  1104.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1105.     INLINE $A86F;
  1106.     {$ENDC}
  1107. PROCEDURE InitPort(port: GrafPtr);
  1108.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1109.     INLINE $A86D;
  1110.     {$ENDC}
  1111. PROCEDURE ClosePort(port: GrafPtr);
  1112.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1113.     INLINE $A87D;
  1114.     {$ENDC}
  1115. {$IFC NOT TARGET_OS_MAC }
  1116. FUNCTION LockPortBits(port: GrafPtr): OSErr;
  1117. FUNCTION UnlockPortBits(port: GrafPtr): OSErr;
  1118. FUNCTION UpdatePort(port: GrafPtr): OSErr;
  1119. FUNCTION GetPortNativeWindow(macPort: GrafPtr): Ptr;
  1120. FUNCTION GetNativeWindowPort(nativeWindow: UNIV Ptr): GrafPtr;
  1121. FUNCTION MacRegionToNativeRegion(macRegion: RgnHandle): Ptr;
  1122. FUNCTION NativeRegionToMacRegion(nativeRegion: UNIV Ptr): RgnHandle;
  1123. {$IFC TARGET_OS_WIN32 }
  1124. FUNCTION GetPortHWND(port: GrafPtr): Ptr;
  1125. FUNCTION GetHWNDPort(theHWND: UNIV Ptr): GrafPtr;
  1126. FUNCTION GetPortHDC(port: GrafPtr): Ptr;
  1127. FUNCTION GetPortHBITMAP(port: GrafPtr): Ptr;
  1128. FUNCTION GetPortHPALETTE(port: GrafPtr): Ptr;
  1129. FUNCTION GetPortHFONT(port: GrafPtr): Ptr;
  1130. FUNCTION GetDIBFromPICT(hPict: PicHandle): Ptr;
  1131. FUNCTION GetPICTFromDIB(h: UNIV Ptr): PicHandle;
  1132. {$ENDC}
  1133. {$ENDC}
  1134.  
  1135. PROCEDURE SetPort(port: GrafPtr);
  1136.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1137.     INLINE $A873;
  1138.     {$ENDC}
  1139. PROCEDURE GetPort(VAR port: GrafPtr);
  1140.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1141.     INLINE $A874;
  1142.     {$ENDC}
  1143. PROCEDURE GrafDevice(device: INTEGER);
  1144.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1145.     INLINE $A872;
  1146.     {$ENDC}
  1147. PROCEDURE SetPortBits({CONST}VAR bm: BitMap);
  1148.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1149.     INLINE $A875;
  1150.     {$ENDC}
  1151. PROCEDURE PortSize(width: INTEGER; height: INTEGER);
  1152.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1153.     INLINE $A876;
  1154.     {$ENDC}
  1155. PROCEDURE MovePortTo(leftGlobal: INTEGER; topGlobal: INTEGER);
  1156.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1157.     INLINE $A877;
  1158.     {$ENDC}
  1159. PROCEDURE SetOrigin(h: INTEGER; v: INTEGER);
  1160.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1161.     INLINE $A878;
  1162.     {$ENDC}
  1163. PROCEDURE SetClip(rgn: RgnHandle);
  1164.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1165.     INLINE $A879;
  1166.     {$ENDC}
  1167. PROCEDURE GetClip(rgn: RgnHandle);
  1168.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1169.     INLINE $A87A;
  1170.     {$ENDC}
  1171. PROCEDURE ClipRect({CONST}VAR r: Rect);
  1172.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1173.     INLINE $A87B;
  1174.     {$ENDC}
  1175. PROCEDURE BackPat({CONST}VAR pat: Pattern);
  1176.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1177.     INLINE $A87C;
  1178.     {$ENDC}
  1179. PROCEDURE InitCursor;
  1180.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1181.     INLINE $A850;
  1182.     {$ENDC}
  1183. PROCEDURE SetCursor({CONST}VAR crsr: Cursor);
  1184.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1185.     INLINE $A851;
  1186.     {$ENDC}
  1187. PROCEDURE HideCursor;
  1188.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1189.     INLINE $A852;
  1190.     {$ENDC}
  1191. PROCEDURE ShowCursor;
  1192.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1193.     INLINE $A853;
  1194.     {$ENDC}
  1195. PROCEDURE ObscureCursor;
  1196.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1197.     INLINE $A856;
  1198.     {$ENDC}
  1199. PROCEDURE HidePen;
  1200.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1201.     INLINE $A896;
  1202.     {$ENDC}
  1203. PROCEDURE ShowPen;
  1204.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1205.     INLINE $A897;
  1206.     {$ENDC}
  1207. PROCEDURE GetPen(VAR pt: Point);
  1208.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1209.     INLINE $A89A;
  1210.     {$ENDC}
  1211. PROCEDURE GetPenState(VAR pnState: PenState);
  1212.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1213.     INLINE $A898;
  1214.     {$ENDC}
  1215. PROCEDURE SetPenState({CONST}VAR pnState: PenState);
  1216.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1217.     INLINE $A899;
  1218.     {$ENDC}
  1219. PROCEDURE PenSize(width: INTEGER; height: INTEGER);
  1220.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1221.     INLINE $A89B;
  1222.     {$ENDC}
  1223. PROCEDURE PenMode(mode: INTEGER);
  1224.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1225.     INLINE $A89C;
  1226.     {$ENDC}
  1227. PROCEDURE PenPat({CONST}VAR pat: Pattern);
  1228.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1229.     INLINE $A89D;
  1230.     {$ENDC}
  1231. PROCEDURE PenNormal;
  1232.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1233.     INLINE $A89E;
  1234.     {$ENDC}
  1235. PROCEDURE MoveTo(h: INTEGER; v: INTEGER);
  1236.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1237.     INLINE $A893;
  1238.     {$ENDC}
  1239. PROCEDURE Move(dh: INTEGER; dv: INTEGER);
  1240.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1241.     INLINE $A894;
  1242.     {$ENDC}
  1243. PROCEDURE LineTo(h: INTEGER; v: INTEGER);
  1244.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1245.     INLINE $A891;
  1246.     {$ENDC}
  1247. PROCEDURE Line(dh: INTEGER; dv: INTEGER);
  1248.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1249.     INLINE $A892;
  1250.     {$ENDC}
  1251. PROCEDURE ForeColor(color: LONGINT);
  1252.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1253.     INLINE $A862;
  1254.     {$ENDC}
  1255. PROCEDURE BackColor(color: LONGINT);
  1256.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1257.     INLINE $A863;
  1258.     {$ENDC}
  1259. PROCEDURE ColorBit(whichBit: INTEGER);
  1260.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1261.     INLINE $A864;
  1262.     {$ENDC}
  1263. PROCEDURE SetRect(VAR r: Rect; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1264.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1265.     INLINE $A8A7;
  1266.     {$ENDC}
  1267. PROCEDURE OffsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1268.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1269.     INLINE $A8A8;
  1270.     {$ENDC}
  1271. PROCEDURE InsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1272.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1273.     INLINE $A8A9;
  1274.     {$ENDC}
  1275. FUNCTION SectRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect): BOOLEAN;
  1276.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1277.     INLINE $A8AA;
  1278.     {$ENDC}
  1279. PROCEDURE UnionRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect);
  1280.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1281.     INLINE $A8AB;
  1282.     {$ENDC}
  1283. FUNCTION EqualRect({CONST}VAR rect1: Rect; {CONST}VAR rect2: Rect): BOOLEAN;
  1284.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1285.     INLINE $A8A6;
  1286.     {$ENDC}
  1287. FUNCTION EmptyRect({CONST}VAR r: Rect): BOOLEAN;
  1288.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1289.     INLINE $A8AE;
  1290.     {$ENDC}
  1291. PROCEDURE FrameRect({CONST}VAR r: Rect);
  1292.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1293.     INLINE $A8A1;
  1294.     {$ENDC}
  1295. PROCEDURE PaintRect({CONST}VAR r: Rect);
  1296.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1297.     INLINE $A8A2;
  1298.     {$ENDC}
  1299. PROCEDURE EraseRect({CONST}VAR r: Rect);
  1300.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1301.     INLINE $A8A3;
  1302.     {$ENDC}
  1303. PROCEDURE InvertRect({CONST}VAR r: Rect);
  1304.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1305.     INLINE $A8A4;
  1306.     {$ENDC}
  1307. PROCEDURE FillRect({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1308.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1309.     INLINE $A8A5;
  1310.     {$ENDC}
  1311. PROCEDURE FrameOval({CONST}VAR r: Rect);
  1312.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1313.     INLINE $A8B7;
  1314.     {$ENDC}
  1315. PROCEDURE PaintOval({CONST}VAR r: Rect);
  1316.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1317.     INLINE $A8B8;
  1318.     {$ENDC}
  1319. PROCEDURE EraseOval({CONST}VAR r: Rect);
  1320.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1321.     INLINE $A8B9;
  1322.     {$ENDC}
  1323. PROCEDURE InvertOval({CONST}VAR r: Rect);
  1324.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1325.     INLINE $A8BA;
  1326.     {$ENDC}
  1327. PROCEDURE FillOval({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1328.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1329.     INLINE $A8BB;
  1330.     {$ENDC}
  1331. PROCEDURE FrameRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1332.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1333.     INLINE $A8B0;
  1334.     {$ENDC}
  1335. PROCEDURE PaintRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1336.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1337.     INLINE $A8B1;
  1338.     {$ENDC}
  1339. PROCEDURE EraseRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1340.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1341.     INLINE $A8B2;
  1342.     {$ENDC}
  1343. PROCEDURE InvertRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1344.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1345.     INLINE $A8B3;
  1346.     {$ENDC}
  1347. PROCEDURE FillRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; {CONST}VAR pat: Pattern);
  1348.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1349.     INLINE $A8B4;
  1350.     {$ENDC}
  1351. PROCEDURE FrameArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1352.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1353.     INLINE $A8BE;
  1354.     {$ENDC}
  1355. PROCEDURE PaintArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1356.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1357.     INLINE $A8BF;
  1358.     {$ENDC}
  1359. PROCEDURE EraseArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1360.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1361.     INLINE $A8C0;
  1362.     {$ENDC}
  1363. PROCEDURE InvertArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1364.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1365.     INLINE $A8C1;
  1366.     {$ENDC}
  1367. PROCEDURE FillArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; {CONST}VAR pat: Pattern);
  1368.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1369.     INLINE $A8C2;
  1370.     {$ENDC}
  1371. FUNCTION NewRgn: RgnHandle;
  1372.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1373.     INLINE $A8D8;
  1374.     {$ENDC}
  1375. PROCEDURE OpenRgn;
  1376.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1377.     INLINE $A8DA;
  1378.     {$ENDC}
  1379. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  1380.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1381.     INLINE $A8DB;
  1382.     {$ENDC}
  1383. FUNCTION BitMapToRegion(region: RgnHandle; {CONST}VAR bMap: BitMap): OSErr;
  1384.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1385.     INLINE $A8D7;
  1386.     {$ENDC}
  1387. PROCEDURE DisposeRgn(rgn: RgnHandle);
  1388.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1389.     INLINE $A8D9;
  1390.     {$ENDC}
  1391. PROCEDURE CopyRgn(srcRgn: RgnHandle; dstRgn: RgnHandle);
  1392.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1393.     INLINE $A8DC;
  1394.     {$ENDC}
  1395. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  1396.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1397.     INLINE $A8DD;
  1398.     {$ENDC}
  1399. PROCEDURE SetRectRgn(rgn: RgnHandle; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1400.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1401.     INLINE $A8DE;
  1402.     {$ENDC}
  1403. PROCEDURE RectRgn(rgn: RgnHandle; {CONST}VAR r: Rect);
  1404.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1405.     INLINE $A8DF;
  1406.     {$ENDC}
  1407. PROCEDURE OffsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1408.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1409.     INLINE $A8E0;
  1410.     {$ENDC}
  1411. PROCEDURE InsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1412.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1413.     INLINE $A8E1;
  1414.     {$ENDC}
  1415. PROCEDURE SectRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1416.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1417.     INLINE $A8E4;
  1418.     {$ENDC}
  1419. PROCEDURE UnionRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1420.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1421.     INLINE $A8E5;
  1422.     {$ENDC}
  1423. PROCEDURE DiffRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1424.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1425.     INLINE $A8E6;
  1426.     {$ENDC}
  1427. PROCEDURE XorRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1428.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1429.     INLINE $A8E7;
  1430.     {$ENDC}
  1431. FUNCTION RectInRgn({CONST}VAR r: Rect; rgn: RgnHandle): BOOLEAN;
  1432.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1433.     INLINE $A8E9;
  1434.     {$ENDC}
  1435. FUNCTION EqualRgn(rgnA: RgnHandle; rgnB: RgnHandle): BOOLEAN;
  1436.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1437.     INLINE $A8E3;
  1438.     {$ENDC}
  1439. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  1440.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1441.     INLINE $A8E2;
  1442.     {$ENDC}
  1443. PROCEDURE FrameRgn(rgn: RgnHandle);
  1444.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1445.     INLINE $A8D2;
  1446.     {$ENDC}
  1447. PROCEDURE PaintRgn(rgn: RgnHandle);
  1448.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1449.     INLINE $A8D3;
  1450.     {$ENDC}
  1451. PROCEDURE EraseRgn(rgn: RgnHandle);
  1452.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1453.     INLINE $A8D4;
  1454.     {$ENDC}
  1455. PROCEDURE InvertRgn(rgn: RgnHandle);
  1456.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1457.     INLINE $A8D5;
  1458.     {$ENDC}
  1459. PROCEDURE FillRgn(rgn: RgnHandle; {CONST}VAR pat: Pattern);
  1460.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1461.     INLINE $A8D6;
  1462.     {$ENDC}
  1463. PROCEDURE ScrollRect({CONST}VAR r: Rect; dh: INTEGER; dv: INTEGER; updateRgn: RgnHandle);
  1464.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1465.     INLINE $A8EF;
  1466.     {$ENDC}
  1467. PROCEDURE CopyBits({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1468.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1469.     INLINE $A8EC;
  1470.     {$ENDC}
  1471. PROCEDURE SeedFill(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER; seedH: INTEGER; seedV: INTEGER);
  1472.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1473.     INLINE $A839;
  1474.     {$ENDC}
  1475. PROCEDURE CalcMask(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER);
  1476.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1477.     INLINE $A838;
  1478.     {$ENDC}
  1479. PROCEDURE CopyMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect);
  1480.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1481.     INLINE $A817;
  1482.     {$ENDC}
  1483. FUNCTION OpenPicture({CONST}VAR picFrame: Rect): PicHandle;
  1484.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1485.     INLINE $A8F3;
  1486.     {$ENDC}
  1487. PROCEDURE PicComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1488.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1489.     INLINE $A8F2;
  1490.     {$ENDC}
  1491. PROCEDURE ClosePicture;
  1492.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1493.     INLINE $A8F4;
  1494.     {$ENDC}
  1495. PROCEDURE DrawPicture(myPicture: PicHandle; {CONST}VAR dstRect: Rect);
  1496.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1497.     INLINE $A8F6;
  1498.     {$ENDC}
  1499. PROCEDURE KillPicture(myPicture: PicHandle);
  1500.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1501.     INLINE $A8F5;
  1502.     {$ENDC}
  1503. FUNCTION OpenPoly: PolyHandle;
  1504.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1505.     INLINE $A8CB;
  1506.     {$ENDC}
  1507. PROCEDURE ClosePoly;
  1508.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1509.     INLINE $A8CC;
  1510.     {$ENDC}
  1511. PROCEDURE KillPoly(poly: PolyHandle);
  1512.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1513.     INLINE $A8CD;
  1514.     {$ENDC}
  1515. PROCEDURE OffsetPoly(poly: PolyHandle; dh: INTEGER; dv: INTEGER);
  1516.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1517.     INLINE $A8CE;
  1518.     {$ENDC}
  1519. PROCEDURE FramePoly(poly: PolyHandle);
  1520.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1521.     INLINE $A8C6;
  1522.     {$ENDC}
  1523. PROCEDURE PaintPoly(poly: PolyHandle);
  1524.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1525.     INLINE $A8C7;
  1526.     {$ENDC}
  1527. PROCEDURE ErasePoly(poly: PolyHandle);
  1528.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1529.     INLINE $A8C8;
  1530.     {$ENDC}
  1531. PROCEDURE InvertPoly(poly: PolyHandle);
  1532.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1533.     INLINE $A8C9;
  1534.     {$ENDC}
  1535. PROCEDURE FillPoly(poly: PolyHandle; {CONST}VAR pat: Pattern);
  1536.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1537.     INLINE $A8CA;
  1538.     {$ENDC}
  1539. PROCEDURE SetPt(VAR pt: Point; h: INTEGER; v: INTEGER);
  1540.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1541.     INLINE $A880;
  1542.     {$ENDC}
  1543. PROCEDURE LocalToGlobal(VAR pt: Point);
  1544.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1545.     INLINE $A870;
  1546.     {$ENDC}
  1547. PROCEDURE GlobalToLocal(VAR pt: Point);
  1548.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1549.     INLINE $A871;
  1550.     {$ENDC}
  1551. FUNCTION Random: INTEGER;
  1552.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1553.     INLINE $A861;
  1554.     {$ENDC}
  1555. PROCEDURE StuffHex(thingPtr: UNIV Ptr; s: Str255);
  1556.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1557.     INLINE $A866;
  1558.     {$ENDC}
  1559. FUNCTION GetPixel(h: INTEGER; v: INTEGER): BOOLEAN;
  1560.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1561.     INLINE $A865;
  1562.     {$ENDC}
  1563. PROCEDURE ScalePt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1564.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1565.     INLINE $A8F8;
  1566.     {$ENDC}
  1567. PROCEDURE MapPt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1568.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1569.     INLINE $A8F9;
  1570.     {$ENDC}
  1571. PROCEDURE MapRect(VAR r: Rect; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1572.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1573.     INLINE $A8FA;
  1574.     {$ENDC}
  1575. PROCEDURE MapRgn(rgn: RgnHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1576.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1577.     INLINE $A8FB;
  1578.     {$ENDC}
  1579. PROCEDURE MapPoly(poly: PolyHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1580.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1581.     INLINE $A8FC;
  1582.     {$ENDC}
  1583. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  1584.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1585.     INLINE $A8EA;
  1586.     {$ENDC}
  1587. PROCEDURE StdRect(verb: GrafVerb; {CONST}VAR r: Rect);
  1588.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1589.     INLINE $A8A0;
  1590.     {$ENDC}
  1591. PROCEDURE StdRRect(verb: GrafVerb; {CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1592.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1593.     INLINE $A8AF;
  1594.     {$ENDC}
  1595. PROCEDURE StdOval(verb: GrafVerb; {CONST}VAR r: Rect);
  1596.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1597.     INLINE $A8B6;
  1598.     {$ENDC}
  1599. PROCEDURE StdArc(verb: GrafVerb; {CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1600.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1601.     INLINE $A8BD;
  1602.     {$ENDC}
  1603. PROCEDURE StdPoly(verb: GrafVerb; poly: PolyHandle);
  1604.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1605.     INLINE $A8C5;
  1606.     {$ENDC}
  1607. PROCEDURE StdRgn(verb: GrafVerb; rgn: RgnHandle);
  1608.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1609.     INLINE $A8D1;
  1610.     {$ENDC}
  1611. PROCEDURE StdBits({CONST}VAR srcBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1612.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1613.     INLINE $A8EB;
  1614.     {$ENDC}
  1615. PROCEDURE StdComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1616.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1617.     INLINE $A8F1;
  1618.     {$ENDC}
  1619. PROCEDURE StdGetPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1620.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1621.     INLINE $A8EE;
  1622.     {$ENDC}
  1623. PROCEDURE StdPutPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1624.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1625.     INLINE $A8F0;
  1626.     {$ENDC}
  1627. PROCEDURE StdOpcode({CONST}VAR fromRect: Rect; {CONST}VAR toRect: Rect; opcode: UInt16; version: SInt16);
  1628.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1629.     INLINE $ABF8;
  1630.     {$ENDC}
  1631. PROCEDURE AddPt(src: Point; VAR dst: Point);
  1632.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1633.     INLINE $A87E;
  1634.     {$ENDC}
  1635. FUNCTION EqualPt(pt1: Point; pt2: Point): BOOLEAN;
  1636.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1637.     INLINE $A881;
  1638.     {$ENDC}
  1639. FUNCTION PtInRect(pt: Point; {CONST}VAR r: Rect): BOOLEAN;
  1640.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1641.     INLINE $A8AD;
  1642.     {$ENDC}
  1643. PROCEDURE Pt2Rect(pt1: Point; pt2: Point; VAR dstRect: Rect);
  1644.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1645.     INLINE $A8AC;
  1646.     {$ENDC}
  1647. PROCEDURE PtToAngle({CONST}VAR r: Rect; pt: Point; VAR angle: INTEGER);
  1648.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1649.     INLINE $A8C3;
  1650.     {$ENDC}
  1651. PROCEDURE SubPt(src: Point; VAR dst: Point);
  1652.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1653.     INLINE $A87F;
  1654.     {$ENDC}
  1655. FUNCTION PtInRgn(pt: Point; rgn: RgnHandle): BOOLEAN;
  1656.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1657.     INLINE $A8E8;
  1658.     {$ENDC}
  1659. PROCEDURE StdLine(newPt: Point);
  1660.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1661.     INLINE $A890;
  1662.     {$ENDC}
  1663. PROCEDURE OpenCPort(port: CGrafPtr);
  1664.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1665.     INLINE $AA00;
  1666.     {$ENDC}
  1667. PROCEDURE InitCPort(port: CGrafPtr);
  1668.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1669.     INLINE $AA01;
  1670.     {$ENDC}
  1671. PROCEDURE CloseCPort(port: CGrafPtr);
  1672.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1673.     INLINE $AA02;
  1674.     {$ENDC}
  1675. FUNCTION NewPixMap: PixMapHandle;
  1676.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1677.     INLINE $AA03;
  1678.     {$ENDC}
  1679. PROCEDURE DisposePixMap(pm: PixMapHandle);
  1680.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1681.     INLINE $AA04;
  1682.     {$ENDC}
  1683. PROCEDURE CopyPixMap(srcPM: PixMapHandle; dstPM: PixMapHandle);
  1684.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1685.     INLINE $AA05;
  1686.     {$ENDC}
  1687. FUNCTION NewPixPat: PixPatHandle;
  1688.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1689.     INLINE $AA07;
  1690.     {$ENDC}
  1691. PROCEDURE DisposePixPat(pp: PixPatHandle);
  1692.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1693.     INLINE $AA08;
  1694.     {$ENDC}
  1695. PROCEDURE CopyPixPat(srcPP: PixPatHandle; dstPP: PixPatHandle);
  1696.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1697.     INLINE $AA09;
  1698.     {$ENDC}
  1699. PROCEDURE PenPixPat(pp: PixPatHandle);
  1700.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1701.     INLINE $AA0A;
  1702.     {$ENDC}
  1703. PROCEDURE BackPixPat(pp: PixPatHandle);
  1704.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1705.     INLINE $AA0B;
  1706.     {$ENDC}
  1707. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  1708.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1709.     INLINE $AA0C;
  1710.     {$ENDC}
  1711. PROCEDURE MakeRGBPat(pp: PixPatHandle; {CONST}VAR myColor: RGBColor);
  1712.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1713.     INLINE $AA0D;
  1714.     {$ENDC}
  1715. PROCEDURE FillCRect({CONST}VAR r: Rect; pp: PixPatHandle);
  1716.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1717.     INLINE $AA0E;
  1718.     {$ENDC}
  1719. PROCEDURE FillCOval({CONST}VAR r: Rect; pp: PixPatHandle);
  1720.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1721.     INLINE $AA0F;
  1722.     {$ENDC}
  1723. PROCEDURE FillCRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; pp: PixPatHandle);
  1724.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1725.     INLINE $AA10;
  1726.     {$ENDC}
  1727. PROCEDURE FillCArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; pp: PixPatHandle);
  1728.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1729.     INLINE $AA11;
  1730.     {$ENDC}
  1731. PROCEDURE FillCRgn(rgn: RgnHandle; pp: PixPatHandle);
  1732.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1733.     INLINE $AA12;
  1734.     {$ENDC}
  1735. PROCEDURE FillCPoly(poly: PolyHandle; pp: PixPatHandle);
  1736.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1737.     INLINE $AA13;
  1738.     {$ENDC}
  1739. PROCEDURE RGBForeColor({CONST}VAR color: RGBColor);
  1740.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1741.     INLINE $AA14;
  1742.     {$ENDC}
  1743. PROCEDURE RGBBackColor({CONST}VAR color: RGBColor);
  1744.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1745.     INLINE $AA15;
  1746.     {$ENDC}
  1747. PROCEDURE SetCPixel(h: INTEGER; v: INTEGER; {CONST}VAR cPix: RGBColor);
  1748.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1749.     INLINE $AA16;
  1750.     {$ENDC}
  1751. PROCEDURE SetPortPix(pm: PixMapHandle);
  1752.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1753.     INLINE $AA06;
  1754.     {$ENDC}
  1755. PROCEDURE GetCPixel(h: INTEGER; v: INTEGER; VAR cPix: RGBColor);
  1756.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1757.     INLINE $AA17;
  1758.     {$ENDC}
  1759. PROCEDURE GetForeColor(VAR color: RGBColor);
  1760.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1761.     INLINE $AA19;
  1762.     {$ENDC}
  1763. PROCEDURE GetBackColor(VAR color: RGBColor);
  1764.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1765.     INLINE $AA1A;
  1766.     {$ENDC}
  1767. PROCEDURE SeedCFill({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; seedH: INTEGER; seedV: INTEGER; matchProc: ColorSearchUPP; matchData: LONGINT);
  1768.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1769.     INLINE $AA50;
  1770.     {$ENDC}
  1771. PROCEDURE CalcCMask({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; {CONST}VAR seedRGB: RGBColor; matchProc: ColorSearchUPP; matchData: LONGINT);
  1772.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1773.     INLINE $AA4F;
  1774.     {$ENDC}
  1775. FUNCTION OpenCPicture({CONST}VAR newHeader: OpenCPicParams): PicHandle;
  1776.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1777.     INLINE $AA20;
  1778.     {$ENDC}
  1779. PROCEDURE OpColor({CONST}VAR color: RGBColor);
  1780.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1781.     INLINE $AA21;
  1782.     {$ENDC}
  1783. PROCEDURE HiliteColor({CONST}VAR color: RGBColor);
  1784.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1785.     INLINE $AA22;
  1786.     {$ENDC}
  1787. PROCEDURE DisposeCTable(cTable: CTabHandle);
  1788.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1789.     INLINE $AA24;
  1790.     {$ENDC}
  1791. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  1792.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1793.     INLINE $AA18;
  1794.     {$ENDC}
  1795. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  1796.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1797.     INLINE $AA1B;
  1798.     {$ENDC}
  1799. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  1800.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1801.     INLINE $AA1C;
  1802.     {$ENDC}
  1803. PROCEDURE AllocCursor;
  1804.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1805.     INLINE $AA1D;
  1806.     {$ENDC}
  1807. PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
  1808.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1809.     INLINE $AA26;
  1810.     {$ENDC}
  1811. {$IFC OLDROUTINELOCATIONS }
  1812. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  1813.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1814.     INLINE $AA1E;
  1815.     {$ENDC}
  1816. PROCEDURE PlotCIcon({CONST}VAR theRect: Rect; theIcon: CIconHandle);
  1817.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1818.     INLINE $AA1F;
  1819.     {$ENDC}
  1820. PROCEDURE DisposeCIcon(theIcon: CIconHandle);
  1821.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1822.     INLINE $AA25;
  1823.     {$ENDC}
  1824. {$ENDC}  {OLDROUTINELOCATIONS}
  1825.  
  1826. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  1827.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1828.     INLINE $AA4E;
  1829.     {$ENDC}
  1830. FUNCTION GetMaxDevice({CONST}VAR globalRect: Rect): GDHandle;
  1831.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1832.     INLINE $AA27;
  1833.     {$ENDC}
  1834. FUNCTION GetCTSeed: LONGINT;
  1835.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1836.     INLINE $AA28;
  1837.     {$ENDC}
  1838. FUNCTION GetDeviceList: GDHandle;
  1839.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1840.     INLINE $AA29;
  1841.     {$ENDC}
  1842. FUNCTION GetMainDevice: GDHandle;
  1843.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1844.     INLINE $AA2A;
  1845.     {$ENDC}
  1846. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  1847.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1848.     INLINE $AA2B;
  1849.     {$ENDC}
  1850. FUNCTION TestDeviceAttribute(gdh: GDHandle; attribute: INTEGER): BOOLEAN;
  1851.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1852.     INLINE $AA2C;
  1853.     {$ENDC}
  1854. PROCEDURE SetDeviceAttribute(gdh: GDHandle; attribute: INTEGER; value: BOOLEAN);
  1855.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1856.     INLINE $AA2D;
  1857.     {$ENDC}
  1858. PROCEDURE InitGDevice(qdRefNum: INTEGER; mode: LONGINT; gdh: GDHandle);
  1859.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1860.     INLINE $AA2E;
  1861.     {$ENDC}
  1862. FUNCTION NewGDevice(refNum: INTEGER; mode: LONGINT): GDHandle;
  1863.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1864.     INLINE $AA2F;
  1865.     {$ENDC}
  1866. PROCEDURE DisposeGDevice(gdh: GDHandle);
  1867.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1868.     INLINE $AA30;
  1869.     {$ENDC}
  1870. PROCEDURE SetGDevice(gd: GDHandle);
  1871.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1872.     INLINE $AA31;
  1873.     {$ENDC}
  1874. FUNCTION GetGDevice: GDHandle;
  1875.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1876.     INLINE $AA32;
  1877.     {$ENDC}
  1878. FUNCTION Color2Index({CONST}VAR myColor: RGBColor): LONGINT;
  1879.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1880.     INLINE $AA33;
  1881.     {$ENDC}
  1882. PROCEDURE Index2Color(index: LONGINT; VAR aColor: RGBColor);
  1883.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1884.     INLINE $AA34;
  1885.     {$ENDC}
  1886. PROCEDURE InvertColor(VAR myColor: RGBColor);
  1887.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1888.     INLINE $AA35;
  1889.     {$ENDC}
  1890. FUNCTION RealColor({CONST}VAR color: RGBColor): BOOLEAN;
  1891.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1892.     INLINE $AA36;
  1893.     {$ENDC}
  1894. PROCEDURE GetSubTable(myColors: CTabHandle; iTabRes: INTEGER; targetTbl: CTabHandle);
  1895.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1896.     INLINE $AA37;
  1897.     {$ENDC}
  1898. PROCEDURE MakeITable(cTabH: CTabHandle; iTabH: ITabHandle; res: INTEGER);
  1899.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1900.     INLINE $AA39;
  1901.     {$ENDC}
  1902. PROCEDURE AddSearch(searchProc: ColorSearchUPP);
  1903.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1904.     INLINE $AA3A;
  1905.     {$ENDC}
  1906. PROCEDURE AddComp(compProc: ColorComplementUPP);
  1907.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1908.     INLINE $AA3B;
  1909.     {$ENDC}
  1910. PROCEDURE DelSearch(searchProc: ColorSearchUPP);
  1911.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1912.     INLINE $AA4C;
  1913.     {$ENDC}
  1914. PROCEDURE DelComp(compProc: ColorComplementUPP);
  1915.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1916.     INLINE $AA4D;
  1917.     {$ENDC}
  1918. PROCEDURE SetClientID(id: INTEGER);
  1919.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1920.     INLINE $AA3C;
  1921.     {$ENDC}
  1922. PROCEDURE ProtectEntry(index: INTEGER; protect: BOOLEAN);
  1923.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1924.     INLINE $AA3D;
  1925.     {$ENDC}
  1926. PROCEDURE ReserveEntry(index: INTEGER; reserve: BOOLEAN);
  1927.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1928.     INLINE $AA3E;
  1929.     {$ENDC}
  1930. PROCEDURE SetEntries(start: INTEGER; count: INTEGER; VAR aTable: CSpecArray);
  1931.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1932.     INLINE $AA3F;
  1933.     {$ENDC}
  1934. PROCEDURE SaveEntries(srcTable: CTabHandle; resultTable: CTabHandle; VAR selection: ReqListRec);
  1935.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1936.     INLINE $AA49;
  1937.     {$ENDC}
  1938. PROCEDURE RestoreEntries(srcTable: CTabHandle; dstTable: CTabHandle; VAR selection: ReqListRec);
  1939.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1940.     INLINE $AA4A;
  1941.     {$ENDC}
  1942. FUNCTION QDError: INTEGER;
  1943.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1944.     INLINE $AA40;
  1945.     {$ENDC}
  1946. PROCEDURE CopyDeepMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1947.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1948.     INLINE $AA51;
  1949.     {$ENDC}
  1950. PROCEDURE DeviceLoop(drawingRgn: RgnHandle; drawingProc: DeviceLoopDrawingUPP; userData: LONGINT; flags: DeviceLoopFlags);
  1951.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1952.     INLINE $ABCA;
  1953.     {$ENDC}
  1954. FUNCTION GetMaskTable: Ptr;
  1955.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1956.     INLINE $A836, $2E88;
  1957.     {$ENDC}
  1958. FUNCTION GetPattern(patternID: INTEGER): PatHandle;
  1959.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1960.     INLINE $A9B8;
  1961.     {$ENDC}
  1962. FUNCTION GetCursor(cursorID: INTEGER): CursHandle;
  1963.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1964.     INLINE $A9B9;
  1965.     {$ENDC}
  1966. FUNCTION GetPicture(pictureID: INTEGER): PicHandle;
  1967.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1968.     INLINE $A9BC;
  1969.     {$ENDC}
  1970. FUNCTION DeltaPoint(ptA: Point; ptB: Point): LONGINT;
  1971.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1972.     INLINE $A94F;
  1973.     {$ENDC}
  1974. PROCEDURE ShieldCursor({CONST}VAR shieldRect: Rect; offsetPt: Point);
  1975.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1976.     INLINE $A855;
  1977.     {$ENDC}
  1978. PROCEDURE ScreenRes(VAR scrnHRes: INTEGER; VAR scrnVRes: INTEGER);
  1979.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1980.     INLINE $225F, $32B8, $0102, $225F, $32B8, $0104;
  1981.     {$ENDC}
  1982. PROCEDURE GetIndPattern(VAR thePat: Pattern; patternListID: INTEGER; index: INTEGER);
  1983. {$IFC OLDROUTINENAMES }
  1984. PROCEDURE DisposPixMap(pm: PixMapHandle);
  1985.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1986.     INLINE $AA04;
  1987.     {$ENDC}
  1988. PROCEDURE DisposPixPat(pp: PixPatHandle);
  1989.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1990.     INLINE $AA08;
  1991.     {$ENDC}
  1992. PROCEDURE DisposCTable(cTable: CTabHandle);
  1993.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1994.     INLINE $AA24;
  1995.     {$ENDC}
  1996. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  1997.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1998.     INLINE $AA26;
  1999.     {$ENDC}
  2000. {$IFC OLDROUTINELOCATIONS }
  2001. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  2002.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2003.     INLINE $AA25;
  2004.     {$ENDC}
  2005. {$ENDC}
  2006. PROCEDURE DisposGDevice(gdh: GDHandle);
  2007.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2008.     INLINE $AA30;
  2009.     {$ENDC}
  2010. {$IFC OLDROUTINELOCATIONS }
  2011. {$ENDC}
  2012. {$ENDC}  {OLDROUTINENAMES}
  2013.  
  2014. {
  2015.     From ToolUtils.i
  2016. }
  2017. PROCEDURE PackBits(VAR srcPtr: Ptr; VAR dstPtr: Ptr; srcBytes: INTEGER);
  2018.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2019.     INLINE $A8CF;
  2020.     {$ENDC}
  2021. PROCEDURE UnpackBits(VAR srcPtr: Ptr; VAR dstPtr: Ptr; dstBytes: INTEGER);
  2022.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2023.     INLINE $A8D0;
  2024.     {$ENDC}
  2025. FUNCTION SlopeFromAngle(angle: INTEGER): Fixed;
  2026.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2027.     INLINE $A8BC;
  2028.     {$ENDC}
  2029. FUNCTION AngleFromSlope(slope: Fixed): INTEGER;
  2030.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2031.     INLINE $A8C4;
  2032.     {$ENDC}
  2033.  
  2034.  
  2035.  
  2036.  
  2037.  
  2038.  
  2039.  
  2040.  
  2041.  
  2042.  
  2043.  
  2044. {$ALIGN RESET}
  2045. {$POP}
  2046.  
  2047. {$SETC UsingIncludes := QuickdrawIncludes}
  2048.  
  2049. {$ENDC} {__QUICKDRAW__}
  2050.  
  2051. {$IFC NOT UsingIncludes}
  2052.  END.
  2053. {$ENDC}
  2054.